home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_iter.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  31KB  |  1,139 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. from test.test_support import run_unittest, TESTFN, unlink, have_unicode
  6. TRIPLETS = [
  7.     (0, 0, 0),
  8.     (0, 0, 1),
  9.     (0, 0, 2),
  10.     (0, 1, 0),
  11.     (0, 1, 1),
  12.     (0, 1, 2),
  13.     (0, 2, 0),
  14.     (0, 2, 1),
  15.     (0, 2, 2),
  16.     (1, 0, 0),
  17.     (1, 0, 1),
  18.     (1, 0, 2),
  19.     (1, 1, 0),
  20.     (1, 1, 1),
  21.     (1, 1, 2),
  22.     (1, 2, 0),
  23.     (1, 2, 1),
  24.     (1, 2, 2),
  25.     (2, 0, 0),
  26.     (2, 0, 1),
  27.     (2, 0, 2),
  28.     (2, 1, 0),
  29.     (2, 1, 1),
  30.     (2, 1, 2),
  31.     (2, 2, 0),
  32.     (2, 2, 1),
  33.     (2, 2, 2)]
  34.  
  35. class BasicIterClass:
  36.     
  37.     def __init__(self, n):
  38.         self.n = n
  39.         self.i = 0
  40.  
  41.     
  42.     def next(self):
  43.         res = self.i
  44.         if res >= self.n:
  45.             raise StopIteration
  46.         
  47.         self.i = res + 1
  48.         return res
  49.  
  50.  
  51.  
  52. class IteratingSequenceClass:
  53.     
  54.     def __init__(self, n):
  55.         self.n = n
  56.  
  57.     
  58.     def __iter__(self):
  59.         return BasicIterClass(self.n)
  60.  
  61.  
  62.  
  63. class SequenceClass:
  64.     
  65.     def __init__(self, n):
  66.         self.n = n
  67.  
  68.     
  69.     def __getitem__(self, i):
  70.         if i <= i:
  71.             pass
  72.         elif i < self.n:
  73.             return i
  74.         else:
  75.             raise IndexError
  76.  
  77.  
  78.  
  79. class TestCase(unittest.TestCase):
  80.     
  81.     def check_iterator(self, it, seq):
  82.         res = []
  83.         while None:
  84.             
  85.             try:
  86.                 val = it.next()
  87.             except StopIteration:
  88.                 break
  89.  
  90.         self.assertEqual(res, seq)
  91.  
  92.     
  93.     def check_for_loop(self, expr, seq):
  94.         res = []
  95.         for val in expr:
  96.             res.append(val)
  97.         
  98.         self.assertEqual(res, seq)
  99.  
  100.     
  101.     def test_iter_basic(self):
  102.         self.check_iterator(iter(range(10)), range(10))
  103.  
  104.     
  105.     def test_iter_idempotency(self):
  106.         seq = range(10)
  107.         it = iter(seq)
  108.         it2 = iter(it)
  109.         self.assert_(it is it2)
  110.  
  111.     
  112.     def test_iter_for_loop(self):
  113.         self.check_for_loop(iter(range(10)), range(10))
  114.  
  115.     
  116.     def test_iter_independence(self):
  117.         seq = range(3)
  118.         res = []
  119.         for i in iter(seq):
  120.             for j in iter(seq):
  121.                 for k in iter(seq):
  122.                     res.append((i, j, k))
  123.                 
  124.             
  125.         
  126.         self.assertEqual(res, TRIPLETS)
  127.  
  128.     
  129.     def test_nested_comprehensions_iter(self):
  130.         seq = range(3)
  131.         res = [ (i, j, k) for i in iter(seq) for j in iter(seq) for k in iter(seq) ]
  132.         self.assertEqual(res, TRIPLETS)
  133.  
  134.     
  135.     def test_nested_comprehensions_for(self):
  136.         seq = range(3)
  137.         res = [ (i, j, k) for i in seq for j in seq for k in seq ]
  138.         self.assertEqual(res, TRIPLETS)
  139.  
  140.     
  141.     def test_iter_class_for(self):
  142.         self.check_for_loop(IteratingSequenceClass(10), range(10))
  143.  
  144.     
  145.     def test_iter_class_iter(self):
  146.         self.check_iterator(iter(IteratingSequenceClass(10)), range(10))
  147.  
  148.     
  149.     def test_seq_class_for(self):
  150.         self.check_for_loop(SequenceClass(10), range(10))
  151.  
  152.     
  153.     def test_seq_class_iter(self):
  154.         self.check_iterator(iter(SequenceClass(10)), range(10))
  155.  
  156.     
  157.     def test_iter_callable(self):
  158.         
  159.         class C:
  160.             
  161.             def __init__(self):
  162.                 self.i = 0
  163.  
  164.             
  165.             def __call__(self):
  166.                 i = self.i
  167.                 self.i = i + 1
  168.                 if i > 100:
  169.                     raise IndexError
  170.                 
  171.                 return i
  172.  
  173.  
  174.         self.check_iterator(iter(C(), 10), range(10))
  175.  
  176.     
  177.     def test_iter_function(self):
  178.         
  179.         def spam(state = [
  180.             0]):
  181.             i = state[0]
  182.             state[0] = i + 1
  183.             return i
  184.  
  185.         self.check_iterator(iter(spam, 10), range(10))
  186.  
  187.     
  188.     def test_iter_function_stop(self):
  189.         
  190.         def spam(state = [
  191.             0]):
  192.             i = state[0]
  193.             if i == 10:
  194.                 raise StopIteration
  195.             
  196.             state[0] = i + 1
  197.             return i
  198.  
  199.         self.check_iterator(iter(spam, 20), range(10))
  200.  
  201.     
  202.     def test_exception_function(self):
  203.         
  204.         def spam(state = [
  205.             0]):
  206.             i = state[0]
  207.             state[0] = i + 1
  208.             if i == 10:
  209.                 raise RuntimeError
  210.             
  211.             return i
  212.  
  213.         res = []
  214.         
  215.         try:
  216.             for x in iter(spam, 20):
  217.                 res.append(x)
  218.         except RuntimeError:
  219.             self.assertEqual(res, range(10))
  220.  
  221.         self.fail('should have raised RuntimeError')
  222.  
  223.     
  224.     def test_exception_sequence(self):
  225.         
  226.         class MySequenceClass(SequenceClass):
  227.             
  228.             def __getitem__(self, i):
  229.                 if i == 10:
  230.                     raise RuntimeError
  231.                 
  232.                 return SequenceClass.__getitem__(self, i)
  233.  
  234.  
  235.         res = []
  236.         
  237.         try:
  238.             for x in MySequenceClass(20):
  239.                 res.append(x)
  240.         except RuntimeError:
  241.             self.assertEqual(res, range(10))
  242.  
  243.         self.fail('should have raised RuntimeError')
  244.  
  245.     
  246.     def test_stop_sequence(self):
  247.         
  248.         class MySequenceClass(SequenceClass):
  249.             
  250.             def __getitem__(self, i):
  251.                 if i == 10:
  252.                     raise StopIteration
  253.                 
  254.                 return SequenceClass.__getitem__(self, i)
  255.  
  256.  
  257.         self.check_for_loop(MySequenceClass(20), range(10))
  258.  
  259.     
  260.     def test_iter_big_range(self):
  261.         self.check_for_loop(iter(range(10000)), range(10000))
  262.  
  263.     
  264.     def test_iter_empty(self):
  265.         self.check_for_loop(iter([]), [])
  266.  
  267.     
  268.     def test_iter_tuple(self):
  269.         self.check_for_loop(iter((0, 1, 2, 3, 4, 5, 6, 7, 8, 9)), range(10))
  270.  
  271.     
  272.     def test_iter_xrange(self):
  273.         self.check_for_loop(iter(xrange(10)), range(10))
  274.  
  275.     
  276.     def test_iter_string(self):
  277.         self.check_for_loop(iter('abcde'), [
  278.             'a',
  279.             'b',
  280.             'c',
  281.             'd',
  282.             'e'])
  283.  
  284.     if have_unicode:
  285.         
  286.         def test_iter_unicode(self):
  287.             self.check_for_loop(iter(unicode('abcde')), [
  288.                 unicode('a'),
  289.                 unicode('b'),
  290.                 unicode('c'),
  291.                 unicode('d'),
  292.                 unicode('e')])
  293.  
  294.     
  295.     
  296.     def test_iter_dict(self):
  297.         dict = { }
  298.         for i in range(10):
  299.             dict[i] = None
  300.         
  301.         self.check_for_loop(dict, dict.keys())
  302.  
  303.     
  304.     def test_iter_file(self):
  305.         f = open(TESTFN, 'w')
  306.         
  307.         try:
  308.             for i in range(5):
  309.                 f.write('%d\n' % i)
  310.         finally:
  311.             f.close()
  312.  
  313.         f = open(TESTFN, 'r')
  314.         
  315.         try:
  316.             self.check_for_loop(f, [
  317.                 '0\n',
  318.                 '1\n',
  319.                 '2\n',
  320.                 '3\n',
  321.                 '4\n'])
  322.             self.check_for_loop(f, [])
  323.         finally:
  324.             f.close()
  325.             
  326.             try:
  327.                 unlink(TESTFN)
  328.             except OSError:
  329.                 pass
  330.  
  331.  
  332.  
  333.     
  334.     def test_builtin_list(self):
  335.         self.assertEqual(list(SequenceClass(5)), range(5))
  336.         self.assertEqual(list(SequenceClass(0)), [])
  337.         self.assertEqual(list(()), [])
  338.         self.assertEqual(list(range(10, -1, -1)), range(10, -1, -1))
  339.         d = {
  340.             'one': 1,
  341.             'two': 2,
  342.             'three': 3 }
  343.         self.assertEqual(list(d), d.keys())
  344.         self.assertRaises(TypeError, list, list)
  345.         self.assertRaises(TypeError, list, 42)
  346.         f = open(TESTFN, 'w')
  347.         
  348.         try:
  349.             for i in range(5):
  350.                 f.write('%d\n' % i)
  351.         finally:
  352.             f.close()
  353.  
  354.         f = open(TESTFN, 'r')
  355.         
  356.         try:
  357.             self.assertEqual(list(f), [
  358.                 '0\n',
  359.                 '1\n',
  360.                 '2\n',
  361.                 '3\n',
  362.                 '4\n'])
  363.             f.seek(0, 0)
  364.             self.assertEqual(list(f), [
  365.                 '0\n',
  366.                 '1\n',
  367.                 '2\n',
  368.                 '3\n',
  369.                 '4\n'])
  370.         finally:
  371.             f.close()
  372.             
  373.             try:
  374.                 unlink(TESTFN)
  375.             except OSError:
  376.                 pass
  377.  
  378.  
  379.  
  380.     
  381.     def test_builtin_tuple(self):
  382.         self.assertEqual(tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
  383.         self.assertEqual(tuple(SequenceClass(0)), ())
  384.         self.assertEqual(tuple([]), ())
  385.         self.assertEqual(tuple(()), ())
  386.         self.assertEqual(tuple('abc'), ('a', 'b', 'c'))
  387.         d = {
  388.             'one': 1,
  389.             'two': 2,
  390.             'three': 3 }
  391.         self.assertEqual(tuple(d), tuple(d.keys()))
  392.         self.assertRaises(TypeError, tuple, list)
  393.         self.assertRaises(TypeError, tuple, 42)
  394.         f = open(TESTFN, 'w')
  395.         
  396.         try:
  397.             for i in range(5):
  398.                 f.write('%d\n' % i)
  399.         finally:
  400.             f.close()
  401.  
  402.         f = open(TESTFN, 'r')
  403.         
  404.         try:
  405.             self.assertEqual(tuple(f), ('0\n', '1\n', '2\n', '3\n', '4\n'))
  406.             f.seek(0, 0)
  407.             self.assertEqual(tuple(f), ('0\n', '1\n', '2\n', '3\n', '4\n'))
  408.         finally:
  409.             f.close()
  410.             
  411.             try:
  412.                 unlink(TESTFN)
  413.             except OSError:
  414.                 pass
  415.  
  416.  
  417.  
  418.     
  419.     def test_builtin_filter(self):
  420.         self.assertEqual(filter(None, SequenceClass(5)), range(1, 5))
  421.         self.assertEqual(filter(None, SequenceClass(0)), [])
  422.         self.assertEqual(filter(None, ()), ())
  423.         self.assertEqual(filter(None, 'abc'), 'abc')
  424.         d = {
  425.             'one': 1,
  426.             'two': 2,
  427.             'three': 3 }
  428.         self.assertEqual(filter(None, d), d.keys())
  429.         self.assertRaises(TypeError, filter, None, list)
  430.         self.assertRaises(TypeError, filter, None, 42)
  431.         
  432.         class Boolean:
  433.             
  434.             def __init__(self, truth):
  435.                 self.truth = truth
  436.  
  437.             
  438.             def __nonzero__(self):
  439.                 return self.truth
  440.  
  441.  
  442.         bTrue = Boolean(1)
  443.         bFalse = Boolean(0)
  444.         
  445.         class Seq:
  446.             
  447.             def __init__(self, *args):
  448.                 self.vals = args
  449.  
  450.             
  451.             def __iter__(self):
  452.                 
  453.                 class SeqIter:
  454.                     
  455.                     def __init__(self, vals):
  456.                         self.vals = vals
  457.                         self.i = 0
  458.  
  459.                     
  460.                     def __iter__(self):
  461.                         return self
  462.  
  463.                     
  464.                     def next(self):
  465.                         i = self.i
  466.                         self.i = i + 1
  467.                         if i < len(self.vals):
  468.                             return self.vals[i]
  469.                         else:
  470.                             raise StopIteration
  471.  
  472.  
  473.                 return SeqIter(self.vals)
  474.  
  475.  
  476.         seq = Seq(*[
  477.             bTrue,
  478.             bFalse] * 25)
  479.         self.assertEqual(filter((lambda x: not x), seq), [
  480.             bFalse] * 25)
  481.         self.assertEqual(filter((lambda x: not x), iter(seq)), [
  482.             bFalse] * 25)
  483.  
  484.     
  485.     def test_builtin_max_min(self):
  486.         self.assertEqual(max(SequenceClass(5)), 4)
  487.         self.assertEqual(min(SequenceClass(5)), 0)
  488.         self.assertEqual(max(8, -1), 8)
  489.         self.assertEqual(min(8, -1), -1)
  490.         d = {
  491.             'one': 1,
  492.             'two': 2,
  493.             'three': 3 }
  494.         self.assertEqual(max(d), 'two')
  495.         self.assertEqual(min(d), 'one')
  496.         self.assertEqual(max(d.itervalues()), 3)
  497.         self.assertEqual(min(iter(d.itervalues())), 1)
  498.         f = open(TESTFN, 'w')
  499.         
  500.         try:
  501.             f.write('medium line\n')
  502.             f.write('xtra large line\n')
  503.             f.write('itty-bitty line\n')
  504.         finally:
  505.             f.close()
  506.  
  507.         f = open(TESTFN, 'r')
  508.         
  509.         try:
  510.             self.assertEqual(min(f), 'itty-bitty line\n')
  511.             f.seek(0, 0)
  512.             self.assertEqual(max(f), 'xtra large line\n')
  513.         finally:
  514.             f.close()
  515.             
  516.             try:
  517.                 unlink(TESTFN)
  518.             except OSError:
  519.                 pass
  520.  
  521.  
  522.  
  523.     
  524.     def test_builtin_map(self):
  525.         self.assertEqual(map(None, SequenceClass(5)), range(5))
  526.         self.assertEqual(map((lambda x: x + 1), SequenceClass(5)), range(1, 6))
  527.         d = {
  528.             'one': 1,
  529.             'two': 2,
  530.             'three': 3 }
  531.         self.assertEqual(map(None, d), d.keys())
  532.         self.assertEqual(map((lambda k, d = d: (k, d[k])), d), d.items())
  533.         dkeys = d.keys()
  534.         expected = [ (_[1], None, i if not i < len(d) or dkeys[i] else None) for i in range(5) ]
  535.         self.assertEqual(map(None, d, SequenceClass(5), iter(d.iterkeys())), expected)
  536.         f = open(TESTFN, 'w')
  537.         
  538.         try:
  539.             for i in range(10):
  540.                 f.write('xy' * i + '\n')
  541.         finally:
  542.             f.close()
  543.  
  544.         f = open(TESTFN, 'r')
  545.         
  546.         try:
  547.             self.assertEqual(map(len, f), range(1, 21, 2))
  548.         finally:
  549.             f.close()
  550.             
  551.             try:
  552.                 unlink(TESTFN)
  553.             except OSError:
  554.                 []
  555.  
  556.  
  557.  
  558.     
  559.     def test_builtin_zip(self):
  560.         self.assertEqual(zip(), [])
  561.         self.assertEqual(zip(*[]), [])
  562.         self.assertEqual(zip(*[
  563.             (1, 2),
  564.             'ab']), [
  565.             (1, 'a'),
  566.             (2, 'b')])
  567.         self.assertRaises(TypeError, zip, None)
  568.         self.assertRaises(TypeError, zip, range(10), 42)
  569.         self.assertRaises(TypeError, zip, range(10), zip)
  570.         self.assertEqual(zip(IteratingSequenceClass(3)), [
  571.             (0,),
  572.             (1,),
  573.             (2,)])
  574.         self.assertEqual(zip(SequenceClass(3)), [
  575.             (0,),
  576.             (1,),
  577.             (2,)])
  578.         d = {
  579.             'one': 1,
  580.             'two': 2,
  581.             'three': 3 }
  582.         self.assertEqual(d.items(), zip(d, d.itervalues()))
  583.         
  584.         class IntsFrom:
  585.             
  586.             def __init__(self, start):
  587.                 self.i = start
  588.  
  589.             
  590.             def __iter__(self):
  591.                 return self
  592.  
  593.             
  594.             def next(self):
  595.                 i = self.i
  596.                 self.i = i + 1
  597.                 return i
  598.  
  599.  
  600.         f = open(TESTFN, 'w')
  601.         
  602.         try:
  603.             f.write('a\nbbb\ncc\n')
  604.         finally:
  605.             f.close()
  606.  
  607.         f = open(TESTFN, 'r')
  608.         
  609.         try:
  610.             self.assertEqual(zip(IntsFrom(0), f, IntsFrom(-100)), [
  611.                 (0, 'a\n', -100),
  612.                 (1, 'bbb\n', -99),
  613.                 (2, 'cc\n', -98)])
  614.         finally:
  615.             f.close()
  616.             
  617.             try:
  618.                 unlink(TESTFN)
  619.             except OSError:
  620.                 pass
  621.  
  622.  
  623.         []([], [ (i,) for i in range(5) ])
  624.         
  625.         class NoGuessLen5:
  626.             
  627.             def __getitem__(self, i):
  628.                 if i >= 5:
  629.                     raise IndexError
  630.                 
  631.                 return i
  632.  
  633.  
  634.         
  635.         class Guess3Len5(NoGuessLen5):
  636.             
  637.             def __len__(self):
  638.                 return 3
  639.  
  640.  
  641.         
  642.         class Guess30Len5(NoGuessLen5):
  643.             
  644.             def __len__(self):
  645.                 return 30
  646.  
  647.  
  648.         self.assertEqual(len(Guess3Len5()), 3)
  649.         self.assertEqual(len(Guess30Len5()), 30)
  650.         self.assertEqual(zip(NoGuessLen5()), zip(range(5)))
  651.         self.assertEqual(zip(Guess3Len5()), zip(range(5)))
  652.         self.assertEqual(zip(Guess30Len5()), zip(range(5)))
  653.         expected = [ (i, i) for i in range(5) ]
  654.         for x in (NoGuessLen5(), Guess3Len5(), Guess30Len5()):
  655.             for y in (NoGuessLen5(), Guess3Len5(), Guess30Len5()):
  656.                 self.assertEqual(zip(x, y), expected)
  657.             
  658.         
  659.  
  660.     
  661.     def test_builtin_reduce(self):
  662.         add = add
  663.         import operator
  664.         self.assertEqual(reduce(add, SequenceClass(5)), 10)
  665.         self.assertEqual(reduce(add, SequenceClass(5), 42), 52)
  666.         self.assertRaises(TypeError, reduce, add, SequenceClass(0))
  667.         self.assertEqual(reduce(add, SequenceClass(0), 42), 42)
  668.         self.assertEqual(reduce(add, SequenceClass(1)), 0)
  669.         self.assertEqual(reduce(add, SequenceClass(1), 42), 42)
  670.         d = {
  671.             'one': 1,
  672.             'two': 2,
  673.             'three': 3 }
  674.         self.assertEqual(reduce(add, d), ''.join(d.keys()))
  675.  
  676.     
  677.     def test_unicode_join_endcase(self):
  678.         
  679.         class OhPhooey:
  680.             
  681.             def __init__(self, seq):
  682.                 self.it = iter(seq)
  683.                 self.i = 0
  684.  
  685.             
  686.             def __iter__(self):
  687.                 return self
  688.  
  689.             
  690.             def next(self):
  691.                 i = self.i
  692.                 self.i = i + 1
  693.                 if i == 2:
  694.                     return unicode('fooled you!')
  695.                 
  696.                 return self.it.next()
  697.  
  698.  
  699.         f = open(TESTFN, 'w')
  700.         
  701.         try:
  702.             f.write('a\n' + 'b\n' + 'c\n')
  703.         finally:
  704.             f.close()
  705.  
  706.         f = open(TESTFN, 'r')
  707.         
  708.         try:
  709.             got = ' - '.join(OhPhooey(f))
  710.             self.assertEqual(got, unicode('a\n - b\n - fooled you! - c\n'))
  711.         finally:
  712.             f.close()
  713.             
  714.             try:
  715.                 unlink(TESTFN)
  716.             except OSError:
  717.                 pass
  718.  
  719.  
  720.  
  721.     if not have_unicode:
  722.         
  723.         def test_unicode_join_endcase(self):
  724.             pass
  725.  
  726.     
  727.     
  728.     def test_in_and_not_in(self):
  729.         for sc5 in (IteratingSequenceClass(5), SequenceClass(5)):
  730.             for i in range(5):
  731.                 self.assert_(i in sc5)
  732.             
  733.             for i in ('abc', -1, 5, 42.420000000000002, (3, 4), [], {
  734.                 1: 1 }, 3 - (0.0+12.0j), sc5):
  735.                 self.assert_(i not in sc5)
  736.             
  737.         
  738.         self.assertRaises(TypeError, (lambda : 3 in 12))
  739.         self.assertRaises(TypeError, (lambda : 3 not in map))
  740.         d = {
  741.             'one': 1,
  742.             'two': 2,
  743.             'three': 3,
  744.             (0.0+1.0j): (0.0+2.0j) }
  745.         for k in d:
  746.             self.assert_(k in d)
  747.             self.assert_(k not in d.itervalues())
  748.         
  749.         for v in d.values():
  750.             self.assert_(v in d.itervalues())
  751.             self.assert_(v not in d)
  752.         
  753.         for k, v in d.iteritems():
  754.             self.assert_((k, v) in d.iteritems())
  755.             self.assert_((v, k) not in d.iteritems())
  756.         
  757.         f = open(TESTFN, 'w')
  758.         
  759.         try:
  760.             f.write('a\nb\nc\n')
  761.         finally:
  762.             f.close()
  763.  
  764.         f = open(TESTFN, 'r')
  765.         
  766.         try:
  767.             for chunk in 'abc':
  768.                 f.seek(0, 0)
  769.                 self.assert_(chunk not in f)
  770.                 f.seek(0, 0)
  771.                 self.assert_(chunk + '\n' in f)
  772.         finally:
  773.             f.close()
  774.             
  775.             try:
  776.                 unlink(TESTFN)
  777.             except OSError:
  778.                 pass
  779.  
  780.  
  781.  
  782.     
  783.     def test_countOf(self):
  784.         countOf = countOf
  785.         import operator
  786.         self.assertEqual(countOf([
  787.             1,
  788.             2,
  789.             2,
  790.             3,
  791.             2,
  792.             5], 2), 3)
  793.         self.assertEqual(countOf((1, 2, 2, 3, 2, 5), 2), 3)
  794.         self.assertEqual(countOf('122325', '2'), 3)
  795.         self.assertEqual(countOf('122325', '6'), 0)
  796.         self.assertRaises(TypeError, countOf, 42, 1)
  797.         self.assertRaises(TypeError, countOf, countOf, countOf)
  798.         d = {
  799.             'one': 3,
  800.             'two': 3,
  801.             'three': 3,
  802.             (0.0+1.0j): (0.0+2.0j) }
  803.         for k in d:
  804.             self.assertEqual(countOf(d, k), 1)
  805.         
  806.         self.assertEqual(countOf(d.itervalues(), 3), 3)
  807.         self.assertEqual(countOf(d.itervalues(), (0.0+2.0j)), 1)
  808.         self.assertEqual(countOf(d.itervalues(), (0.0+1.0j)), 0)
  809.         f = open(TESTFN, 'w')
  810.         
  811.         try:
  812.             f.write('a\nb\nc\nb\n')
  813.         finally:
  814.             f.close()
  815.  
  816.         f = open(TESTFN, 'r')
  817.         
  818.         try:
  819.             for letter, count in (('a', 1), ('b', 2), ('c', 1), ('d', 0)):
  820.                 f.seek(0, 0)
  821.                 self.assertEqual(countOf(f, letter + '\n'), count)
  822.         finally:
  823.             f.close()
  824.             
  825.             try:
  826.                 unlink(TESTFN)
  827.             except OSError:
  828.                 pass
  829.  
  830.  
  831.  
  832.     
  833.     def test_indexOf(self):
  834.         indexOf = indexOf
  835.         import operator
  836.         self.assertEqual(indexOf([
  837.             1,
  838.             2,
  839.             2,
  840.             3,
  841.             2,
  842.             5], 1), 0)
  843.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 2), 1)
  844.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 3), 3)
  845.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 5), 5)
  846.         self.assertRaises(ValueError, indexOf, (1, 2, 2, 3, 2, 5), 0)
  847.         self.assertRaises(ValueError, indexOf, (1, 2, 2, 3, 2, 5), 6)
  848.         self.assertEqual(indexOf('122325', '2'), 1)
  849.         self.assertEqual(indexOf('122325', '5'), 5)
  850.         self.assertRaises(ValueError, indexOf, '122325', '6')
  851.         self.assertRaises(TypeError, indexOf, 42, 1)
  852.         self.assertRaises(TypeError, indexOf, indexOf, indexOf)
  853.         f = open(TESTFN, 'w')
  854.         
  855.         try:
  856.             f.write('a\nb\nc\nd\ne\n')
  857.         finally:
  858.             f.close()
  859.  
  860.         f = open(TESTFN, 'r')
  861.         
  862.         try:
  863.             fiter = iter(f)
  864.             self.assertEqual(indexOf(fiter, 'b\n'), 1)
  865.             self.assertEqual(indexOf(fiter, 'd\n'), 1)
  866.             self.assertEqual(indexOf(fiter, 'e\n'), 0)
  867.             self.assertRaises(ValueError, indexOf, fiter, 'a\n')
  868.         finally:
  869.             f.close()
  870.             
  871.             try:
  872.                 unlink(TESTFN)
  873.             except OSError:
  874.                 pass
  875.  
  876.  
  877.         iclass = IteratingSequenceClass(3)
  878.         for i in range(3):
  879.             self.assertEqual(indexOf(iclass, i), i)
  880.         
  881.         self.assertRaises(ValueError, indexOf, iclass, -1)
  882.  
  883.     
  884.     def test_writelines(self):
  885.         f = file(TESTFN, 'w')
  886.         
  887.         try:
  888.             self.assertRaises(TypeError, f.writelines, None)
  889.             self.assertRaises(TypeError, f.writelines, 42)
  890.             f.writelines([
  891.                 '1\n',
  892.                 '2\n'])
  893.             f.writelines(('3\n', '4\n'))
  894.             f.writelines({
  895.                 '5\n': None })
  896.             f.writelines({ })
  897.             
  898.             class Iterator:
  899.                 
  900.                 def __init__(self, start, finish):
  901.                     self.start = start
  902.                     self.finish = finish
  903.                     self.i = self.start
  904.  
  905.                 
  906.                 def next(self):
  907.                     if self.i >= self.finish:
  908.                         raise StopIteration
  909.                     
  910.                     result = str(self.i) + '\n'
  911.                     self.i += 1
  912.                     return result
  913.  
  914.                 
  915.                 def __iter__(self):
  916.                     return self
  917.  
  918.  
  919.             
  920.             class Whatever:
  921.                 
  922.                 def __init__(self, start, finish):
  923.                     self.start = start
  924.                     self.finish = finish
  925.  
  926.                 
  927.                 def __iter__(self):
  928.                     return Iterator(self.start, self.finish)
  929.  
  930.  
  931.             f.writelines(Whatever(6, 6 + 2000))
  932.             f.close()
  933.             f = file(TESTFN)
  934.             expected = [ str(i) + '\n' for i in range(1, 2006) ]
  935.             self.assertEqual(list(f), expected)
  936.         finally:
  937.             f.close()
  938.             
  939.             try:
  940.                 unlink(TESTFN)
  941.             except OSError:
  942.                 pass
  943.  
  944.  
  945.  
  946.     
  947.     def test_unpack_iter(self):
  948.         (a, b) = (1, 2)
  949.         self.assertEqual((a, b), (1, 2))
  950.         (a, b, c) = IteratingSequenceClass(3)
  951.         self.assertEqual((a, b, c), (0, 1, 2))
  952.         
  953.         try:
  954.             (a, b) = IteratingSequenceClass(3)
  955.         except ValueError:
  956.             pass
  957.  
  958.         self.fail('should have raised ValueError')
  959.         
  960.         try:
  961.             (a, b, c) = IteratingSequenceClass(2)
  962.         except ValueError:
  963.             pass
  964.  
  965.         self.fail('should have raised ValueError')
  966.         
  967.         try:
  968.             (a, b, c) = len
  969.         except TypeError:
  970.             pass
  971.  
  972.         self.fail('should have raised TypeError')
  973.         (a, b, c) = {
  974.             1: 42,
  975.             2: 42,
  976.             3: 42 }.itervalues()
  977.         self.assertEqual((a, b, c), (42, 42, 42))
  978.         f = open(TESTFN, 'w')
  979.         lines = ('a\n', 'bb\n', 'ccc\n')
  980.         
  981.         try:
  982.             for line in lines:
  983.                 f.write(line)
  984.         finally:
  985.             f.close()
  986.  
  987.         f = open(TESTFN, 'r')
  988.         
  989.         try:
  990.             (a, b, c) = f
  991.             self.assertEqual((a, b, c), lines)
  992.         finally:
  993.             f.close()
  994.             
  995.             try:
  996.                 unlink(TESTFN)
  997.             except OSError:
  998.                 pass
  999.  
  1000.  
  1001.         (a, b) = IteratingSequenceClass(2)
  1002.         (c,) = {
  1003.             42: 24 }
  1004.         self.assertEqual((a, b, c), (0, 1, 42))
  1005.         
  1006.         class C(object):
  1007.             count = 0
  1008.             
  1009.             def __new__(cls):
  1010.                 cls.count += 1
  1011.                 return object.__new__(cls)
  1012.  
  1013.             
  1014.             def __del__(self):
  1015.                 cls = self.__class__
  1016.                 if not cls.count > 0:
  1017.                     raise AssertionError
  1018.                 cls.count -= 1
  1019.  
  1020.  
  1021.         x = C()
  1022.         self.assertEqual(C.count, 1)
  1023.         del x
  1024.         self.assertEqual(C.count, 0)
  1025.         l = [
  1026.             C(),
  1027.             C(),
  1028.             C()]
  1029.         self.assertEqual(C.count, 3)
  1030.         
  1031.         try:
  1032.             (a, b) = iter(l)
  1033.         except ValueError:
  1034.             pass
  1035.  
  1036.         del l
  1037.         self.assertEqual(C.count, 0)
  1038.  
  1039.     
  1040.     def test_sinkstate_list(self):
  1041.         a = range(5)
  1042.         b = iter(a)
  1043.         self.assertEqual(list(b), range(5))
  1044.         a.extend(range(5, 10))
  1045.         self.assertEqual(list(b), [])
  1046.  
  1047.     
  1048.     def test_sinkstate_tuple(self):
  1049.         a = (0, 1, 2, 3, 4)
  1050.         b = iter(a)
  1051.         self.assertEqual(list(b), range(5))
  1052.         self.assertEqual(list(b), [])
  1053.  
  1054.     
  1055.     def test_sinkstate_string(self):
  1056.         a = 'abcde'
  1057.         b = iter(a)
  1058.         self.assertEqual(list(b), [
  1059.             'a',
  1060.             'b',
  1061.             'c',
  1062.             'd',
  1063.             'e'])
  1064.         self.assertEqual(list(b), [])
  1065.  
  1066.     
  1067.     def test_sinkstate_sequence(self):
  1068.         a = SequenceClass(5)
  1069.         b = iter(a)
  1070.         self.assertEqual(list(b), range(5))
  1071.         a.n = 10
  1072.         self.assertEqual(list(b), [])
  1073.  
  1074.     
  1075.     def test_sinkstate_callable(self):
  1076.         
  1077.         def spam(state = [
  1078.             0]):
  1079.             i = state[0]
  1080.             state[0] = i + 1
  1081.             if i == 10:
  1082.                 raise AssertionError, "shouldn't have gotten this far"
  1083.             
  1084.             return i
  1085.  
  1086.         b = iter(spam, 5)
  1087.         self.assertEqual(list(b), range(5))
  1088.         self.assertEqual(list(b), [])
  1089.  
  1090.     
  1091.     def test_sinkstate_dict(self):
  1092.         a = {
  1093.             1: 1,
  1094.             2: 2,
  1095.             0: 0,
  1096.             4: 4,
  1097.             3: 3 }
  1098.         for b in (iter(a), a.iterkeys(), a.iteritems(), a.itervalues()):
  1099.             b = iter(a)
  1100.             self.assertEqual(len(list(b)), 5)
  1101.             self.assertEqual(list(b), [])
  1102.         
  1103.  
  1104.     
  1105.     def test_sinkstate_yield(self):
  1106.         
  1107.         def gen():
  1108.             for i in range(5):
  1109.                 yield i
  1110.             
  1111.  
  1112.         b = gen()
  1113.         self.assertEqual(list(b), range(5))
  1114.         self.assertEqual(list(b), [])
  1115.  
  1116.     
  1117.     def test_sinkstate_range(self):
  1118.         a = xrange(5)
  1119.         b = iter(a)
  1120.         self.assertEqual(list(b), range(5))
  1121.         self.assertEqual(list(b), [])
  1122.  
  1123.     
  1124.     def test_sinkstate_enumerate(self):
  1125.         a = range(5)
  1126.         e = enumerate(a)
  1127.         b = iter(e)
  1128.         self.assertEqual(list(b), zip(range(5), range(5)))
  1129.         self.assertEqual(list(b), [])
  1130.  
  1131.  
  1132.  
  1133. def test_main():
  1134.     run_unittest(TestCase)
  1135.  
  1136. if __name__ == '__main__':
  1137.     test_main()
  1138.  
  1139.